home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp48_2 / areuh.tar / areuh / assembler / amnemo.c < prev    next >
C/C++ Source or Header  |  1990-10-10  |  6KB  |  236 lines
  1. /*
  2.  * Authors :
  3.  *   Pierre DAVID (pda@masi.ibp.fr or pda@frunip62.bitnet)
  4.  *   Janick TAILLANDIER
  5.  *
  6.  * This program can be freely used or distributed as long as this
  7.  * note is kept.
  8.  *
  9.  * This program is provided "as is".
  10.  */
  11.  
  12. /******************************************************************************
  13.  
  14.                                 AREUH ASSEMBLER
  15.  
  16.                               MNEMONIC PROCESSING
  17.  
  18.  
  19. ps_mnemo, find_mnemo, hex, dec
  20.  
  21. ******************************************************************************/
  22.  
  23. #include "aglobal.h"
  24.  
  25. extern void regtest(), regarith(), reglogic(), branches(), rtnyes(), ptrtest(),
  26.             stattest(), setptr(), setstat(), dparith(), datatrans(), nibhex(),
  27.             lchex(), dxhex(), nibasc(), lcasc(),
  28.  
  29.             bss(), eject(), endx(), list(), title(), stitle(), lex(), id(),
  30.             msg(), poll(), entryx(), charx(), key(), token(), bin(), chain(),
  31.             endtxt(), endifx(), absx(), rdsymb(), elsex(), ifx() ;
  32.  
  33.  
  34. /******************************************************************************
  35.  
  36.                                  PROCESS_MNEMO
  37.  
  38.  
  39. synopsis : ps_mnemo (line, modif, ad)
  40.            uchar *line, *modif
  41.            struct mnemo_desc *ad 
  42. description : pass control to the appropriate routine, to process the opcode.
  43.  
  44. ******************************************************************************/
  45.  
  46. ps_mnemo (line, modif, ad)
  47. uchar *line, *modif ;
  48. struct mnemo_desc *ad ;
  49. {
  50.     switch (ad->m_class)
  51.     {
  52.         case 1 :
  53.             regtest(ad, modif) ;
  54.             break ;
  55.         case 2 :
  56.             regarith(ad, modif) ;
  57.             break ;
  58.         case 3 :
  59.             reglogic(modif) ;
  60.             break ;
  61.         case 4 :
  62.             branches(ad, modif) ;
  63.             break ;
  64.         case 7 :
  65.             rtnyes() ;
  66.             break ;
  67.         case 8 :
  68.             ptrtest(modif) ;
  69.             break ;
  70.         case 9 :
  71.             stattest(modif) ;
  72.             break ;
  73.         case 10 :
  74.             setptr(modif) ;
  75.             break ;
  76.         case 11 :
  77.             setstat(modif) ;
  78.             break ;
  79.         case 12 :
  80.             dparith(modif) ;
  81.             break ;
  82.         case 13 :
  83.             datatrans(modif) ;
  84.             break ;
  85.         case 14 :
  86.             nibhex(modif) ;
  87.             break ;
  88.         case 15 :
  89.             lchex(modif) ;
  90.             break ;
  91.         case 16 :
  92.             dxhex(modif) ;
  93.             break ;
  94.         case 17 :
  95.             nibasc(modif) ;
  96.             break ;
  97.         case 18 :
  98.             lcasc(modif) ;
  99.             break ;
  100.         case 19 :
  101.             bss(modif) ;
  102.             break ;
  103.         case 20 :
  104.             eject() ;
  105.             break ;
  106.         case 21 :
  107.             endx() ;
  108.             break ;
  109.         case 23 :
  110.             list(modif) ;
  111.             break ;
  112.         case 24 :
  113.             title(modif) ;
  114.             break ;
  115.         case 25 :
  116.             stitle(modif) ;
  117.             break ;
  118.         case 28 :
  119.             lex(modif, line) ;
  120.             break ;
  121.         case 29 :
  122.             id(modif, line) ;
  123.             break ;
  124.         case 30 :
  125.             msg(modif, line) ;
  126.             break ;
  127.         case 31 :
  128.             poll(modif, line) ;
  129.             break ;
  130.         case 32 :
  131.             entryx(modif, line) ;
  132.             break ;
  133.         case 33 :
  134.             charx(modif, line) ;
  135.             break ;
  136.         case 34 :
  137.             key(modif, line) ;
  138.             break ;
  139.         case 35 :
  140.             token(modif, line) ;
  141.             break ;
  142.         case 36 :
  143.             bin(modif, line) ;
  144.             break ;
  145.         case 38 :
  146.             chain(modif, line) ;
  147.             break ;
  148.         case 39 :
  149.             endtxt(line) ;
  150.             break ;
  151.         case 40 :
  152.             endifx() ;
  153.             break ;
  154.         case 41 :
  155.             absx(modif) ;
  156.             break ;
  157.         case 42 :
  158.             rdsymb(modif) ;
  159.             break ;
  160.         case 43 :
  161.             elsex() ;
  162.             break ;
  163.         case 44 :
  164.             ifx(modif) ;
  165.             break ;
  166.     }
  167. }
  168.  
  169.  
  170. /******************************************************************************
  171.  
  172.                                    FIND_MNEMO
  173.  
  174.  
  175. synopsis : struct mnemo_desc *find_mnemo (mnemo)
  176.            char *mnemo
  177. description : finds index of a mnemonic in mnemo_table, and returns it, -1
  178.               if not found.
  179.  
  180. ******************************************************************************/
  181.  
  182. struct mnemo_desc *find_mnemo (mnemo)
  183. uchar *mnemo ;
  184. {
  185.     int i, m, b = 1 ;
  186.     long int h = 0 ;
  187.  
  188.     for (i=0; i<6; i++)
  189.         h = (h<<3) + ((b) ? ((b=(int)mnemo[i])&7) : 0) ;
  190.     h %= 43 ;
  191.     i = h_opcode[h] ; m = h_opcode[++h] ;
  192.     while (i<m)
  193.     {
  194.         if (strcmp(mnemo, mnemo_table[i].m_text))  i++ ;
  195.         else break ;
  196.     }
  197.     return ((i==m) ? (struct mnemo_desc *)NULL : &mnemo_table[i]) ;
  198. }
  199.  
  200.  
  201. /******************************************************************************
  202.  
  203.                                    HEX
  204.  
  205.  
  206. synopsis : uchar hex (digit)
  207.            int digit
  208. description : returns the hexadecimal representation of integer 'digit' (in
  209.               ['0'..'9','A'..'Z']).
  210.  
  211. ******************************************************************************/
  212.  
  213. uchar hex (digit)
  214. int digit ;
  215. {
  216.     return ((uchar) ( (digit<=9) ? digit+48 : digit+55) ) ;
  217. }
  218.  
  219.  
  220. /*****************************************************************************
  221.  
  222.                                    DEC
  223.  
  224.  
  225. synopsis : int dec (digit)
  226.            uchar digit
  227. description : returns the decimal equivalent of hexadecimal character 'digit'.
  228.  
  229. *****************************************************************************/
  230.  
  231. int dec (digit)
  232. uchar digit ;
  233. {
  234.     return ((digit<'A') ? (int) digit - 48 : (int) digit - 55 ) ;
  235. }
  236.